const fs = require('fs');
const path = require('path');

// வெளியீட்டு கோப்பு பாதையை வரையறுக்கவும்
const outputFile = path.join(__dirname, 'writestream-example.txt');

// கோப்புக்கு எழுத ஒரு WriteStream உருவாக்க
const writeStream = fs.createWriteStream(outputFile, {
  // விருப்பங்கள்
  flags: 'w',          // எழுதுவதற்கு 'w' (ஏற்கனவே உள்ள கோப்பை மேலெழுதும்)
  encoding: 'utf8',    // சரங்களுக்கான encoding ஐ அமை
  mode: 0o666,         // கோப்பு பயன்முறை (அனுமதிகள்)
  autoClose: true      // ஸ்ட்ரீம் முடிவடையும் போது தானாகவே கோப்பு descriptor ஐ மூடு
});

console.log('File WriteStream properties:');
console.log(`- Path: ${writeStream.path}`);
console.log(`- Pending: ${writeStream.pending}`);
console.log(`- High Water Mark: ${writeStream.writableHighWaterMark} bytes`);

// ஸ்ட்ரீம் நிகழ்வுகளைக் கையாள
writeStream.on('open', (fd) => {
  console.log(`File opened with descriptor: ${fd}`);
});

writeStream.on('ready', () => {
  console.log('WriteStream is ready');
  
  // ஸ்ட்ரீமுக்கு தரவை எழுது
  writeStream.write('Hello, this is the first line.\n');
  writeStream.write('This is the second line.\n');
  writeStream.write('And this is the third line.\n');
  
  // அனைத்து தரவையும் எழுதிய பிறகு ஸ்ட்ரீமை முடி
  writeStream.end('This is the final line.\n', () => {
    console.log('Finished writing to the file');
    console.log(`Total bytes written: ${writeStream.bytesWritten}`);
  });
});

// drain நிகழ்வைக் கையாள (buffer காலியாகும் போது)
writeStream.on('drain', () => {
  console.log('Write buffer drained');
});

// finish நிகழ்வைக் கையாள (end() மற்றும் அனைத்து தரவும் flush செய்யப்பட்ட பிறகு)
writeStream.on('finish', () => {
  console.log('All writes have been completed');
  
  // சரிபார்க்க கோப்பு உள்ளடக்கங்களை மீண்டும் வாசி
  fs.readFile(outputFile, 'utf8', (err, data) => {
    if (err) {
      console.error(`Error reading file: ${err.message}`);
      return;
    }
    
    console.log('\nFile content:');
    console.log('-'.repeat(20));
    console.log(data);
    console.log('-'.repeat(20));
    
    // மாதிரி கோப்பை சுத்தம் செய்
    fs.unlink(outputFile, (err) => {
      if (err) {
        console.error(`Error removing file: ${err.message}`);
        return;
      }
      console.log('Sample file removed');
    });
  });
});

writeStream.on('close', () => {
  console.log('Stream closed');
});

writeStream.on('error', (err) => {
  console.error(`Error: ${err.message}`);
});

const fs = require('fs');
const path = require('path');

// வெளியீட்டு கோப்பு பாதையை வரையறுக்கவும்
const backpressureFile = path.join(__dirname, 'backpressure-example.txt');

// backpressure ஐ நிரூபிக்க ஒரு சிறிய highWaterMark உடன் ஒரு WriteStream உருவாக்க
const writeStream = fs.createWriteStream(backpressureFile, {
  highWaterMark: 1024 // 1KB buffer (backpressure ஐ நிரூபிக்க சிறியது)
});

// எத்தனை chunks எழுதப்பட்டுள்ளன என்பதற்கான counter
let chunksWritten = 0;
let drainEvents = 0;

// backpressure ஏற்படும் வரை தரவை எழுதும் செயல்பாடு
function writeChunks() {
  console.log('Writing chunks...');
  
  // தரவின் ஒரு பெரிய chunk ஐ உருவாக்கு
  const chunk = 'a'.repeat(256); // ஒரு chunk க்கு 256 பைட்டுகள்
  
  // பல chunks எழுத முயற்சி
  let canContinue = true;
  
  while (canContinue && chunksWritten < 100) {
    // chunk ஐ எழுத முயற்சி
    canContinue = writeStream.write(`Chunk ${chunksWritten}: ${chunk}\n`);
    chunksWritten++;
    
    if (chunksWritten % 10 === 0) {
      console.log(`Wrote ${chunksWritten} chunks so far`);
    }
    
    // canContinue false எனில், நாம் backpressure ஐத் தாக்கினோம்
    if (!canContinue) {
      console.log(`Backpressure hit after ${chunksWritten} chunks. Waiting for drain...`);
      
      // தொடர்வதற்கு முன் drain நிகழ்வுக்குக் காத்திரு
      writeStream.once('drain', () => {
        drainEvents++;
        console.log(`Drain event #${drainEvents} occurred. Resuming writes...`);
        writeChunks(); // எழுதுவதைத் தொடர்
      });
    }
  }
  
  // அனைத்து chunks எழுதப்பட்டிருந்தால், ஸ்ட்ரீமை முடி
  if (chunksWritten >= 100) {
    writeStream.end('\nAll chunks have been written.\n', () => {
      console.log('Ended the WriteStream after writing all chunks');
    });
  }
}

// ஸ்ட்ரீம் தயாராக இருக்கும் போது chunks எழுதத் தொடங்கு
writeStream.on('ready', () => {
  console.log('WriteStream is ready with highWaterMark =',
    writeStream.writableHighWaterMark, 'bytes');
  
  // chunks எழுதத் தொடங்கு
  writeChunks();
});

// finish நிகழ்வைக் கையாள
writeStream.on('finish', () => {
  console.log('\nWrite operation completed');
  console.log(`Total chunks written: ${chunksWritten}`);
  console.log(`Total drain events: ${drainEvents}`);
  console.log(`Total bytes written: ${writeStream.bytesWritten}`);
  
  // மாதிரி கோப்பை சுத்தம் செய்
  fs.unlink(backpressureFile, (err) => {
    if (err) {
      console.error(`Error removing file: ${err.message}`);
      return;
    }
    console.log('Sample file removed');
  });
});

// பிழைகளைக் கையாள
writeStream.on('error', (err) => {
  console.error(`Error: ${err.message}`);
});

const fs = require('fs');
const path = require('path');

// வெளியீட்டு கோப்பு பாதைகளை வரையறுக்கவும்
const uncorkedFile = path.join(__dirname, 'uncorked-example.txt');
const corkedFile = path.join(__dirname, 'corked-example.txt');

// நிரூபணத்தை இயக்கும் செயல்பாடு
function demonstrateCorkUncork() {
  console.log('Demonstrating cork() and uncork() methods');
  
  // 1. corking இல்லாமல் எழுது
  const uncorkedStream = fs.createWriteStream(uncorkedFile);
  
  uncorkedStream.on('finish', () => {
    console.log(`Uncorked stream finished. Bytes written: ${uncorkedStream.bytesWritten}`);
    
    // 2. இப்போது corking உடன் எழுது
    const corkedStream = fs.createWriteStream(corkedFile);
    
    corkedStream.on('finish', () => {
      console.log(`Corked stream finished. Bytes written: ${corkedStream.bytesWritten}`);
      
      // கோப்புகளை ஒப்பிடு
      fs.readFile(uncorkedFile, 'utf8', (err, uncorkedData) => {
        if (err) {
          console.error(`Error reading uncorked file: ${err.message}`);
          return;
        }
        
        fs.readFile(corkedFile, 'utf8', (err, corkedData) => {
          if (err) {
            console.error(`Error reading corked file: ${err.message}`);
            return;
          }
          
          console.log('\nFile comparison:');
          console.log(`- Uncorked file size: ${uncorkedData.length} bytes`);
          console.log(`- Corked file size: ${corkedData.length} bytes`);
          console.log(`- Content identical: ${uncorkedData === corkedData}`);
          
          // மாதிரி கோப்புகளை சுத்தம் செய்
          fs.unlinkSync(uncorkedFile);
          fs.unlinkSync(corkedFile);
          console.log('Sample files removed');
        });
      });
    });
    
    // cork செயல்பாட்டைத் தொடங்கு
    console.log('Writing with cork()...');
    corkedStream.cork();
    
    // தரவின் பல chunks எழுது
    for (let i = 0; i < 1000; i++) {
      corkedStream.write(`Line ${i}: This data is being corked.\n`);
    }
    
    // buffer ஐ flush செய்ய uncork - உண்மையான பயன்பாடுகளில், எழுதுதல்களை ஒன்றாக batch செய்ய பல முறை cork/uncork செய்யலாம்
    corkedStream.uncork();
    
    // ஸ்ட்ரீமை முடி
    corkedStream.end();
  });
  
  // corking இல்லாமல் எழுது
  console.log('Writing without cork()...');
  for (let i = 0; i < 1000; i++) {
    uncorkedStream.write(`Line ${i}: This data is not being corked.\n`);
  }
  
  // ஸ்ட்ரீமை முடி
  uncorkedStream.end();
}

// நிரூபணத்தை இயக்கு
demonstrateCorkUncork();

// process.stdout ஒரு WriteStream ஆகும்

// stdout க்கு அடிப்படை எழுதுதல்
process.stdout.write('Hello, ');
process.stdout.write('world!\n');

// stdout வண்ணங்களை ஆதரிக்கிறதா எனச் சரிபார்க்கவும் (பெரும்பாலான முனையங்கள் செய்கின்றன)
const supportsColor = process.stdout.hasColors && process.stdout.hasColors();

// வண்ணம் ஆதரிக்கப்பட்டால் எளிய வடிவமைப்பு
if (supportsColor) {
  // வண்ணங்களுக்கான ANSI escape codes
  const colors = {
    red: '\x1b[31m',
    green: '\x1b[32m',
    yellow: '\x1b[33m',
    blue: '\x1b[34m',
    reset: '\x1b[0m'
  };
  
  process.stdout.write(`${colors.red}This text is red.\n${colors.reset}`);
  process.stdout.write(`${colors.green}This text is green.\n${colors.reset}`);
  process.stdout.write(`${colors.blue}This text is blue.\n${colors.reset}`);
} else {
  process.stdout.write('Your terminal does not support colors.\n');
}

// அட்டவணை தரவை எழுதுதல்
const table = [
  ['Name', 'Age', 'Country'],
  ['John', '28', 'USA'],
  ['Maria', '32', 'Spain'],
  ['Yuki', '24', 'Japan']
];

process.stdout.write('\nTable Example:\n');
table.forEach(row => {
  process.stdout.write(`${row[0].padEnd(10)}${row[1].padEnd(5)}${row[2]}\n`);
});

// முன்னேற்ற பட்டி எடுத்துக்காட்டு
process.stdout.write('\nProgress Bar Example:\n');

function showProgress(percent) {
  const width = 40;
  const completed = Math.floor(width * (percent / 100));
  const remaining = width - completed;
  
  // முன்னேற்ற பட்டியை உருவாக்கு
  const bar = '[' + '#'.repeat(completed) + ' '.repeat(remaining) + ']';
  
  // வரியின் தொடக்கத்திற்குத் திரும்ப \r ஐப் பயன்படுத்து
  process.stdout.write(`\r${bar} ${percent}%`);
  
  // முடிந்தால், ஒரு புதிய வரியைச் சேர்
  if (percent === 100) {
    process.stdout.write('\nComplete!\n');
  }
}

// முன்னேற்றத்தை உருவகப்படுத்து
let progress = 0;
const progressInterval = setInterval(() => {
  progress += 10;
  showProgress(progress);
  
  if (progress >= 100) {
    clearInterval(progressInterval);
  }
}, 300);

// குறிப்பு: முன்னேற்ற பட்டி எடுத்துக்காட்டு W3Schools TryIt எடிட்டரை விட ஒரு முனையத்தில் அதிக பயனுள்ளதாக இருக்கும்

const http = require('http');

// ஒரு HTTP சேவையகத்தை உருவாக்கு
const server = http.createServer((req, res) => {
  // res ஒரு http.ServerResponse, இது ஒரு WriteStream ஆகும்
  console.log(`Received ${req.method} request to ${req.url}`);
  
  // பதில் தலைப்புகளை அமை
  res.setHeader('Content-Type', 'text/html');
  
  // client ஒரு streaming பதிலைக் கோரியதா எனச் சரிபார்க்கவும்
  if (req.url === '/stream') {
    // ஒரு பெரிய பதிலை streaming செய்வதை நிரூபிக்கவும்
    streamLargeResponse(res);
  } else {
    // இயல்புநிலை handler - எடுத்துக்காட்டுகளுக்கான இணைப்புகளைக் காட்டு
    res.writeHead(200, {'Content-Type': 'text/html'});
    res.end(`
      
      
      
      
        
HTTP WriteStream Examples
        

          
Stream a large response
        
      
      
    `);
  }
});

// துண்டு துண்டாக ஒரு பெரிய பதிலை streaming செய்யும் செயல்பாடு
function streamLargeResponse(res) {
  // பொருத்தமான தலைப்புகளை அமை
  res.writeHead(200, {
    'Content-Type': 'text/html',
    'Transfer-Encoding': 'chunked'  // chunked transfer encoding ஐ இயக்கு
  });
  
  // HTML தலைப்பை எழுது
  res.write(`
    
    
    
      
      
    
    
      
Streaming Response Example
      
This response is being streamed in chunks with delays between them.
      

  `);
  
  // அனுப்ப வேண்டிய chunks எண்ணிக்கை
  const totalChunks = 10;
  let sentChunks = 0;
  
  // ஒரு chunk ஐ அனுப்பும் செயல்பாடு
  function sendChunk() {
    sentChunks++;
    
    const now = new Date().toISOString();
    const chunk = `
      

        
Chunk ${sentChunks} of ${totalChunks}
        
Sent at: ${now}
        
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam vehicula magna eros,
        eget gravida dolor fermentum non.
      
    `;
    
    // பதிலுக்கு chunk ஐ எழுது
    res.write(chunk);
    
    // அனைத்து chunks அனுப்பப்பட்டிருந்தால், பதிலை முடி
    if (sentChunks >= totalChunks) {
      // HTML footer ஐ எழுது
      res.end(`
        
        
All chunks have been sent.
      
      
      `);
      console.log('Finished streaming response');
    } else {
      // இல்லையெனில், அடுத்த chunk ஐ திட்டமிடு
      setTimeout(sendChunk, 500); // ஒவ்வொரு 500ms க்கும் ஒரு chunk ஐ அனுப்பு
    }
  }
  
  // chunks அனுப்பத் தொடங்கு
  console.log('Starting to stream response');
  sendChunk();
}

// சேவையகத்தைத் தொடங்கு
const PORT = 8080;
server.listen(PORT, () => {
  console.log(`HTTP WriteStream example server running at http://localhost:${PORT}`);
});

// குறிப்பு: இதைச் செயல்பாட்டில் பார்க்க, நீங்கள் சேவையகத்தை இயக்கி உலாவியைத் திறக்க வேண்டும்
// http://localhost:8080

const fs = require('fs');
const path = require('path');

// சரியான பிழை கையாளுதலுடன் ஒரு கோப்புக்கு எழுதும் செயல்பாடு
function writeWithErrorHandling(filePath, data) {
  console.log(`Attempting to write to: ${filePath}`);
  
  // WriteStream ஐ உருவாக்கு
  const writeStream = fs.createWriteStream(filePath);
  
  // முடிவு அல்லது பிழையைப் பிடிக்க promise ஐ அமை
  return new Promise((resolve, reject) => {
    // பிழைகளைக் கையாள
    writeStream.on('error', (err) => {
      console.error(`Error writing to ${filePath}: ${err.message}`);
      
      // ஸ்ட்ரீம் சரியாக அழிக்கப்பட்டுள்ளதா என்பதை உறுதிப்படுத்து
      writeStream.destroy();
      reject(err);
    });
    
    // வெற்றிகரமான நிறைவைக் கையாள
    writeStream.on('finish', () => {
      console.log(`Successfully wrote ${writeStream.bytesWritten} bytes to ${filePath}`);
      resolve(writeStream.bytesWritten);
    });
    
    // தரவை எழுது
    writeStream.write(data, (err) => {
      if (err) {
        console.error(`Error during write operation: ${err.message}`);
        // இந்த வழக்கில் 'error' நிகழ்வும் வெளியிடப்படும்
      } else {
        console.log('Data written successfully, ending stream');
        writeStream.end();
      }
    });
  });
}

// செல்லுபடியாகும் மற்றும் செல்லாத கோப்பு பாதைகளுடன் சோதிக்கவும்
const validPath = path.join(__dirname, 'valid-path.txt');
const invalidPath = path.join('/', 'invalid', 'path', 'file.txt'); // பெரும்பாலான அமைப்புகளில் செல்லாததாக இருக்க வாய்ப்புள்ளது

// எடுத்துக்காட்டு 1: ஒரு செல்லுபடியாகும் பாதைக்கு எழுதுதல்
console.log('Example 1: Writing to a valid path');
writeWithErrorHandling(validPath, 'This is test content for error handling example')
  .then(bytesWritten => {
    console.log(`Verified: ${bytesWritten} bytes written`);
    
    // சோதனை கோப்பை சுத்தம் செய்
    fs.unlinkSync(validPath);
    console.log('Test file removed');
    
    // எடுத்துக்காட்டு 2: ஒரு செல்லாத பாதைக்கு எழுதுதல்
    console.log('\nExample 2: Writing to an invalid path');
    return writeWithErrorHandling(invalidPath, 'This should fail');
  })
  .catch(err => {
    console.log('Error caught in Promise catch:', err.message);
  });

// எடுத்துக்காட்டு 3: அழிக்கப்பட்ட ஸ்ட்ரீம்களை நிரூபித்தல்
console.log('\nExample 3: Demonstrating destroyed streams');

function demonstrateDestroyedStream() {
  const destroyTestFile = path.join(__dirname, 'destroy-test.txt');
  const writeStream = fs.createWriteStream(destroyTestFile);
  
  writeStream.on('error', (err) => {
    console.error(`Destruction error: ${err.message}`);
  });
  
  writeStream.on('close', () => {
    console.log('Destroyed stream closed');
    
    // கோப்பு உருவாக்கப்பட்டால் சுத்தம் செய்
    if (fs.existsSync(destroyTestFile)) {
      fs.unlinkSync(destroyTestFile);
      console.log('Destroy test file removed');
    }
  });
  
  // சில தரவை எழுது
  writeStream.write('Initial data before destruction\n');
  
  // பிழையுடன் ஸ்ட்ரீமை அழி
  console.log('Deliberately destroying the stream');
  writeStream.destroy(new Error('Stream manually destroyed'));
  
  // அழித்த பிறகு எழுத முயற்சி (சத்தமில்லாமல் தோல்வியடைய வேண்டும்)
  const writeResult = writeStream.write('This should not be written');
  console.log(`Attempt to write after destruction returned: ${writeResult}`);
}

demonstrateDestroyedStream();